home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / planner / util / var.c < prev   
Encoding:
C/C++ Source or Header  |  1992-08-27  |  3.7 KB  |  157 lines
  1. /*     
  2.  *      FILE
  3.  *         var
  4.  *     
  5.  *      DESCRIPTION
  6.  *         Var node manipulation routines
  7.  *     $Header: /private/postgres/src/planner/util/RCS/var.c,v 1.18 1992/08/21 05:48:14 mer Exp $
  8.  */
  9.  
  10. /*
  11.  *      EXPORTS
  12.  *             pull_var_clause
  13.  *             var_equal
  14.  *             numlevels
  15.  */
  16.  
  17. #include "planner/internal.h"
  18. #include "planner/var.h"
  19. #include "nodes/primnodes.h"
  20. #include "nodes/primnodes.a.h"
  21. #include "planner/clauses.h"
  22.  
  23. LispValue
  24. pull_agg_clause(clause)
  25.      LispValue clause;
  26. {
  27.     LispValue retval = LispNil;
  28.     if(null(clause))
  29.         retval=LispNil;
  30.     else if(agg_clause(clause))
  31.         retval = CDR(clause);
  32.         /* this brings the clause down to
  33.          * (aggname, query, tlist, -1)
  34.          */
  35.         else if (single_node (clause)) 
  36.         retval = LispNil;
  37.     else if (or_clause(clause)) {
  38.         LispValue temp;
  39.         LispValue result = LispNil;
  40.         /* mapcan */
  41.         foreach (temp,get_orclauseargs(clause) )
  42.           retval = nconc(retval, pull_agg_clause(CAR(temp)));
  43.         }
  44.     else if (is_funcclause (clause)) {
  45.         LispValue temp;
  46.         /* mapcan */
  47.         foreach(temp,get_funcargs(clause))
  48.           retval = nconc (retval,pull_agg_clause(CAR(temp)));
  49.         }
  50.     else if (IsA(clause,ArrayRef)) {
  51.         retval = pull_agg_clause(get_refindexpr((ArrayRef)clause));
  52.       }
  53.     else if (not_clause (clause))
  54.         retval = pull_agg_clause(get_notclausearg(clause));
  55.     else if (is_clause(clause))
  56.         retval = nconc (pull_agg_clause ((LispValue)get_leftop (clause)),
  57.             pull_agg_clause ((LispValue)get_rightop (clause)));
  58.     else
  59.         retval=  LispNil;
  60.     return (retval);
  61. }
  62.  
  63. /*    
  64.  *        pull_var_clause
  65.  *    
  66.  *        Recursively pulls all var nodes from a clause by pulling vars from the
  67.  *        left and right operands of the clause.  
  68.  *    
  69.  *        Returns list of varnodes found.
  70.  *    
  71.  */
  72.  
  73. LispValue
  74. pull_var_clause (clause)
  75.      LispValue clause ;
  76. {
  77.     LispValue retval = LispNil;
  78.  
  79.     if (null (clause) ) 
  80.       return(LispNil);
  81.     else if (IsA(clause,Var))
  82.       retval = lispCons (clause,LispNil);
  83.     else if ( IsA(clause,Iter) )
  84.           retval = pull_var_clause(get_iterexpr((Iter)clause));
  85.     else if (single_node (clause)) 
  86.       retval = LispNil;
  87.     else if (or_clause (clause)) {
  88.         LispValue temp;
  89.         LispValue result = LispNil;
  90.         /* mapcan */
  91.         foreach (temp,get_orclauseargs(clause) )
  92.           retval = nconc(retval, pull_var_clause(CAR(temp)));
  93.     } else if (is_funcclause (clause)) {
  94.         LispValue temp;
  95.         /* mapcan */
  96.         foreach(temp,get_funcargs(clause)) 
  97.           retval = nconc (retval,pull_var_clause(CAR(temp)));
  98.     } else if (IsA(clause,ArrayRef)) {
  99.         retval = nconc(pull_var_clause(get_refindexpr((ArrayRef)clause)),
  100.                pull_var_clause(get_refexpr((ArrayRef)clause)));
  101.     } else if (not_clause (clause))
  102.       retval = pull_var_clause (get_notclausearg (clause));
  103.     else if (is_clause (clause)) 
  104.       retval = nconc (pull_var_clause ((LispValue)get_leftop (clause)),
  105.               pull_var_clause ((LispValue)get_rightop (clause)));
  106.     else retval = LispNil;
  107.     return (retval);
  108. }
  109.  
  110. /*    
  111.  *        var_equal
  112.  *    
  113.  *        Returns t iff two var nodes correspond to the same attribute.
  114.  */
  115. bool
  116. var_equal (var1,var2)
  117.      LispValue var1,var2;
  118. {
  119.     if (IsA (var1,Var) && IsA (var2,Var) &&
  120.     (get_varno ((Var)var1) == get_varno ((Var)var2)) &&
  121.     (get_vartype ((Var)var1) == get_vartype ((Var)var2)) && 
  122.     (get_varattno ((Var)var1) == get_varattno ((Var)var2))) {
  123.  
  124.          return(true);
  125.     } else 
  126.       return(false);
  127.     
  128. } /* var_equal */
  129.  
  130.  
  131. /*    
  132.  *        numlevels
  133.  *    
  134.  *        Returns the number of nesting levels in a var-node
  135.  *    
  136.  */
  137.  
  138. /*  .. replace-resultvar-refs
  139.  */
  140.  
  141. int
  142. numlevels (var)
  143.      Var var;
  144. {
  145.     return(length (CDR ( get_varid (var))));
  146. }
  147.  
  148. ObjectId
  149. var_getrelid(var)
  150.     Var var;
  151. {
  152.     int rt_id;
  153.  
  154.     rt_id = CInteger(CAR(get_varid(var)));
  155.     return (ObjectId) CInteger(getrelid(rt_id, _query_range_table_));
  156. }
  157.